{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Softmax exercise\n",
    "\n",
    "*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n",
    "\n",
    "This exercise is analogous to the SVM exercise. You will:\n",
    "\n",
    "- implement a fully-vectorized **loss function** for the Softmax classifier\n",
    "- implement the fully-vectorized expression for its **analytic gradient**\n",
    "- **check your implementation** with numerical gradient\n",
    "- use a validation set to **tune the learning rate and regularization** strength\n",
    "- **optimize** the loss function with **SGD**\n",
    "- **visualize** the final learned weights\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "from cs231n.data_utils import load_CIFAR10\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading extenrnal modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train data shape:  (49000, 3073)\n",
      "Train labels shape:  (49000,)\n",
      "Validation data shape:  (1000, 3073)\n",
      "Validation labels shape:  (1000,)\n",
      "Test data shape:  (1000, 3073)\n",
      "Test labels shape:  (1000,)\n",
      "dev data shape:  (500, 3073)\n",
      "dev labels shape:  (500,)\n"
     ]
    }
   ],
   "source": [
    "def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000, num_dev=500):\n",
    "    \"\"\"\n",
    "    Load the CIFAR-10 dataset from disk and perform preprocessing to prepare\n",
    "    it for the linear classifier. These are the same steps as we used for the\n",
    "    SVM, but condensed to a single function.  \n",
    "    \"\"\"\n",
    "    # Load the raw CIFAR-10 data\n",
    "    cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n",
    "    \n",
    "    # Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n",
    "    try:\n",
    "       del X_train, y_train\n",
    "       del X_test, y_test\n",
    "       print('Clear previously loaded data.')\n",
    "    except:\n",
    "       pass\n",
    "\n",
    "    X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n",
    "    \n",
    "    # subsample the data\n",
    "    mask = list(range(num_training, num_training + num_validation))\n",
    "    X_val = X_train[mask]\n",
    "    y_val = y_train[mask]\n",
    "    mask = list(range(num_training))\n",
    "    X_train = X_train[mask]\n",
    "    y_train = y_train[mask]\n",
    "    mask = list(range(num_test))\n",
    "    X_test = X_test[mask]\n",
    "    y_test = y_test[mask]\n",
    "    mask = np.random.choice(num_training, num_dev, replace=False)\n",
    "    X_dev = X_train[mask]\n",
    "    y_dev = y_train[mask]\n",
    "    \n",
    "    # Preprocessing: reshape the image data into rows\n",
    "    X_train = np.reshape(X_train, (X_train.shape[0], -1))\n",
    "    X_val = np.reshape(X_val, (X_val.shape[0], -1))\n",
    "    X_test = np.reshape(X_test, (X_test.shape[0], -1))\n",
    "    X_dev = np.reshape(X_dev, (X_dev.shape[0], -1))\n",
    "    \n",
    "    # Normalize the data: subtract the mean image\n",
    "    mean_image = np.mean(X_train, axis = 0)\n",
    "    X_train -= mean_image\n",
    "    X_val -= mean_image\n",
    "    X_test -= mean_image\n",
    "    X_dev -= mean_image\n",
    "    \n",
    "    # add bias dimension and transform into columns\n",
    "    X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])\n",
    "    X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])\n",
    "    X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])\n",
    "    X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])\n",
    "    \n",
    "    return X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev\n",
    "\n",
    "\n",
    "# Invoke the above function to get our data.\n",
    "X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev = get_CIFAR10_data()\n",
    "print('Train data shape: ', X_train.shape)\n",
    "print('Train labels shape: ', y_train.shape)\n",
    "print('Validation data shape: ', X_val.shape)\n",
    "print('Validation labels shape: ', y_val.shape)\n",
    "print('Test data shape: ', X_test.shape)\n",
    "print('Test labels shape: ', y_test.shape)\n",
    "print('dev data shape: ', X_dev.shape)\n",
    "print('dev labels shape: ', y_dev.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Softmax Classifier\n",
    "\n",
    "Your code for this section will all be written inside `cs231n/classifiers/softmax.py`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.3504208509204547\n",
      "loss: 2.350421\n",
      "sanity check: 2.302585\n"
     ]
    }
   ],
   "source": [
    "# First implement the naive softmax loss function with nested loops.\n",
    "# Open the file cs231n/classifiers/softmax.py and implement the\n",
    "# softmax_loss_naive function.\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_naive\n",
    "import time\n",
    "\n",
    "# Generate a random softmax weight matrix and use it to compute the loss.\n",
    "W = np.random.randn(3073, 10) * 0.0001\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As a rough sanity check, our loss should be something close to -log(0.1).\n",
    "print('loss: %f' % loss)\n",
    "print('sanity check: %f' % (-np.log(0.1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Inline Question 1**\n",
    "\n",
    "Why do we expect our loss to be close to -log(0.1)? Explain briefly.**\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$ *Fill this in* \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.3504208509204547\n",
      "2.3504236589966196\n",
      "2.350418077495484\n",
      "numerical: 0.279075 analytic: 0.279075, relative error: 3.463789e-08\n",
      "2.350401429828503\n",
      "2.350440313751581\n",
      "numerical: -1.944196 analytic: -1.944196, relative error: 4.122514e-08\n",
      "2.350415323555667\n",
      "2.3504264227635914\n",
      "numerical: -0.554960 analytic: -0.554961, relative error: 1.334793e-07\n",
      "2.350413889115979\n",
      "2.3504278419518854\n",
      "numerical: -0.697642 analytic: -0.697642, relative error: 5.328716e-10\n",
      "2.3504216006525036\n",
      "2.35042013439087\n",
      "numerical: 0.073313 analytic: 0.073313, relative error: 1.067364e-07\n",
      "2.3504807510523626\n",
      "2.350361007465875\n",
      "numerical: 5.987179 analytic: 5.987179, relative error: 1.815490e-08\n",
      "2.3503967242902633\n",
      "2.350445017851548\n",
      "numerical: -2.414678 analytic: -2.414678, relative error: 1.457898e-08\n",
      "2.350428802211014\n",
      "2.3504129305916064\n",
      "numerical: 0.793581 analytic: 0.793581, relative error: 2.778686e-08\n",
      "2.350408312565067\n",
      "2.350433439176851\n",
      "numerical: -1.256331 analytic: -1.256331, relative error: 2.810595e-08\n",
      "2.350409242060599\n",
      "2.3504324968563877\n",
      "numerical: -1.162740 analytic: -1.162740, relative error: 5.037818e-08\n",
      "2.358074786844264\n",
      "2.3580758267609156\n",
      "2.3580737897628143\n",
      "numerical: 0.101850 analytic: 0.101850, relative error: 3.577477e-07\n",
      "2.3580558566808305\n",
      "2.358093777552796\n",
      "numerical: -1.896044 analytic: -1.896044, relative error: 2.845800e-08\n",
      "2.3580873605413557\n",
      "2.358062253516935\n",
      "numerical: 1.255351 analytic: 1.255351, relative error: 3.597346e-08\n",
      "2.358085574309715\n",
      "2.3580640329495237\n",
      "numerical: 1.077068 analytic: 1.077068, relative error: 2.000463e-08\n",
      "2.3580557866915774\n",
      "2.358093836239072\n",
      "numerical: -1.902477 analytic: -1.902477, relative error: 1.868043e-08\n",
      "2.358058405880203\n",
      "2.3580912078285015\n",
      "numerical: -1.640097 analytic: -1.640097, relative error: 1.146704e-08\n",
      "2.3581016150461585\n",
      "2.3580479958410545\n",
      "numerical: 2.680960 analytic: 2.680960, relative error: 1.541307e-08\n",
      "2.3580722436553283\n",
      "2.3580773686180687\n",
      "numerical: -0.256248 analytic: -0.256248, relative error: 5.904426e-09\n",
      "2.358092944222539\n",
      "2.358056668545987\n",
      "numerical: 1.813784 analytic: 1.813784, relative error: 3.501397e-08\n",
      "2.358054399472108\n",
      "2.358095227847976\n",
      "numerical: -2.041419 analytic: -2.041419, relative error: 3.213030e-08\n"
     ]
    }
   ],
   "source": [
    "# Complete the implementation of softmax_loss_naive and implement a (naive)\n",
    "# version of the gradient that uses nested loops.\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As we did for the SVM, use numeric gradient checking as a debugging tool.\n",
    "# The numeric gradient should be close to the analytic gradient.\n",
    "from cs231n.gradient_check import grad_check_sparse\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 0.0)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)\n",
    "\n",
    "# similar to SVM case, do another gradient check with regularization\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 5e1)\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 5e1)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "naive loss: 2.350421e+00 computed in 0.181191s\n",
      "vectorized loss: 2.350421e+00 computed in 0.006983s\n",
      "Loss difference: 0.000000\n",
      "Gradient difference: 0.000000\n"
     ]
    }
   ],
   "source": [
    "# Now that we have a naive implementation of the softmax loss function and its gradient,\n",
    "# implement a vectorized version in softmax_loss_vectorized.\n",
    "# The two versions should compute the same results, but the vectorized version should be\n",
    "# much faster.\n",
    "tic = time.time()\n",
    "loss_naive, grad_naive = softmax_loss_naive(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('naive loss: %e computed in %fs' % (loss_naive, toc - tic))\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_vectorized\n",
    "tic = time.time()\n",
    "loss_vectorized, grad_vectorized = softmax_loss_vectorized(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('vectorized loss: %e computed in %fs' % (loss_vectorized, toc - tic))\n",
    "\n",
    "# As we did for the SVM, we use the Frobenius norm to compare the two versions\n",
    "# of the gradient.\n",
    "grad_difference = np.linalg.norm(grad_naive - grad_vectorized, ord='fro')\n",
    "print('Loss difference: %f' % np.abs(loss_naive - loss_vectorized))\n",
    "print('Gradient difference: %f' % grad_difference)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "tuning",
    "tags": [
     "code"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 0 / 2000: loss 394.018335\n",
      "iteration 100 / 2000: loss 237.920065\n",
      "iteration 200 / 2000: loss 144.405052\n",
      "iteration 300 / 2000: loss 88.163559\n",
      "iteration 400 / 2000: loss 54.083938\n",
      "iteration 500 / 2000: loss 33.531654\n",
      "iteration 600 / 2000: loss 21.075383\n",
      "iteration 700 / 2000: loss 13.573083\n",
      "iteration 800 / 2000: loss 9.019924\n",
      "iteration 900 / 2000: loss 6.192158\n",
      "iteration 1000 / 2000: loss 4.558681\n",
      "iteration 1100 / 2000: loss 3.635468\n",
      "iteration 1200 / 2000: loss 2.953742\n",
      "iteration 1300 / 2000: loss 2.505964\n",
      "iteration 1400 / 2000: loss 2.326979\n",
      "iteration 1500 / 2000: loss 2.293527\n",
      "iteration 1600 / 2000: loss 2.139733\n",
      "iteration 1700 / 2000: loss 2.006416\n",
      "iteration 1800 / 2000: loss 2.102034\n",
      "iteration 1900 / 2000: loss 1.987495\n",
      "iteration 0 / 2000: loss 776.911063\n",
      "iteration 100 / 2000: loss 284.923483\n",
      "iteration 200 / 2000: loss 105.661883\n",
      "iteration 300 / 2000: loss 39.915720\n",
      "iteration 400 / 2000: loss 15.965016\n",
      "iteration 500 / 2000: loss 7.237730\n",
      "iteration 600 / 2000: loss 3.877575\n",
      "iteration 700 / 2000: loss 2.752870\n",
      "iteration 800 / 2000: loss 2.323142\n",
      "iteration 900 / 2000: loss 2.188059\n",
      "iteration 1000 / 2000: loss 2.099127\n",
      "iteration 1100 / 2000: loss 2.107237\n",
      "iteration 1200 / 2000: loss 2.105221\n",
      "iteration 1300 / 2000: loss 2.067139\n",
      "iteration 1400 / 2000: loss 2.088772\n",
      "iteration 1500 / 2000: loss 2.083770\n",
      "iteration 1600 / 2000: loss 2.112928\n",
      "iteration 1700 / 2000: loss 2.058817\n",
      "iteration 1800 / 2000: loss 2.062040\n",
      "iteration 1900 / 2000: loss 2.076437\n",
      "iteration 0 / 2000: loss 388.856552\n",
      "iteration 100 / 2000: loss 32.793132\n",
      "iteration 200 / 2000: loss 4.503530\n",
      "iteration 300 / 2000: loss 2.139761\n",
      "iteration 400 / 2000: loss 2.175181\n",
      "iteration 500 / 2000: loss 1.984984\n",
      "iteration 600 / 2000: loss 2.017535\n",
      "iteration 700 / 2000: loss 1.948127\n",
      "iteration 800 / 2000: loss 2.068422\n",
      "iteration 900 / 2000: loss 2.005214\n",
      "iteration 1000 / 2000: loss 1.984924\n",
      "iteration 1100 / 2000: loss 1.975831\n",
      "iteration 1200 / 2000: loss 2.058832\n",
      "iteration 1300 / 2000: loss 2.080526\n",
      "iteration 1400 / 2000: loss 2.128608\n",
      "iteration 1500 / 2000: loss 2.015288\n",
      "iteration 1600 / 2000: loss 2.028650\n",
      "iteration 1700 / 2000: loss 2.021652\n",
      "iteration 1800 / 2000: loss 2.061123\n",
      "iteration 1900 / 2000: loss 2.021461\n",
      "iteration 0 / 2000: loss 781.423646\n",
      "iteration 100 / 2000: loss 6.966632\n",
      "iteration 200 / 2000: loss 2.137478\n",
      "iteration 300 / 2000: loss 2.115120\n",
      "iteration 400 / 2000: loss 2.041953\n",
      "iteration 500 / 2000: loss 2.034182\n",
      "iteration 600 / 2000: loss 2.139067\n",
      "iteration 700 / 2000: loss 2.115488\n",
      "iteration 800 / 2000: loss 2.049859\n",
      "iteration 900 / 2000: loss 2.141823\n",
      "iteration 1000 / 2000: loss 2.057627\n",
      "iteration 1100 / 2000: loss 2.017187\n",
      "iteration 1200 / 2000: loss 2.013192\n",
      "iteration 1300 / 2000: loss 2.113437\n",
      "iteration 1400 / 2000: loss 2.145490\n",
      "iteration 1500 / 2000: loss 2.105249\n",
      "iteration 1600 / 2000: loss 2.168775\n",
      "iteration 1700 / 2000: loss 2.039546\n",
      "iteration 1800 / 2000: loss 2.062894\n",
      "iteration 1900 / 2000: loss 2.097998\n",
      "lr 1.000000e-07 reg 2.500000e+04 train accuracy: 0.348816 val accuracy: 0.360000\n",
      "lr 1.000000e-07 reg 5.000000e+04 train accuracy: 0.325776 val accuracy: 0.342000\n",
      "lr 5.000000e-07 reg 2.500000e+04 train accuracy: 0.347265 val accuracy: 0.367000\n",
      "lr 5.000000e-07 reg 5.000000e+04 train accuracy: 0.326796 val accuracy: 0.348000\n",
      "best validation accuracy achieved during cross-validation: 0.367000\n"
     ]
    }
   ],
   "source": [
    "# Use the validation set to tune hyperparameters (regularization strength and\n",
    "# learning rate). You should experiment with different ranges for the learning\n",
    "# rates and regularization strengths; if you are careful you should be able to\n",
    "# get a classification accuracy of over 0.35 on the validation set.\n",
    "\n",
    "from cs231n.classifiers import Softmax\n",
    "results = {}\n",
    "best_val = -1\n",
    "best_softmax = None\n",
    "\n",
    "################################################################################\n",
    "# TODO:                                                                        #\n",
    "# Use the validation set to set the learning rate and regularization strength. #\n",
    "# This should be identical to the validation that you did for the SVM; save    #\n",
    "# the best trained softmax classifer in best_softmax.                          #\n",
    "################################################################################\n",
    "\n",
    "# Provided as a reference. You may or may not want to change these hyperparameters\n",
    "learning_rates = [1e-7, 5e-7]\n",
    "regularization_strengths = [2.5e4, 5e4]\n",
    "\n",
    "for lr in learning_rates:\n",
    "    for reg in regularization_strengths:\n",
    "        softmax=Softmax();\n",
    "        softmax.train(X_train,y_train,lr,reg,num_iters=2000,batch_size=200,\\\n",
    "                     verbose=True)\n",
    "        YTrainPred=softmax.predict(X_train)\n",
    "        train_accuracy=np.mean(YTrainPred==y_train)\n",
    "        YValPred=softmax.predict(X_val)\n",
    "        val_accuracy=np.mean(YValPred==y_val)\n",
    "        results[(lr,reg)]=(train_accuracy,val_accuracy)\n",
    "        if val_accuracy>best_val:\n",
    "            best_val=val_accuracy\n",
    "            best_softmax=softmax\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "pass\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "    \n",
    "# Print out results.\n",
    "for lr, reg in sorted(results):\n",
    "    train_accuracy, val_accuracy = results[(lr, reg)]\n",
    "    print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n",
    "                lr, reg, train_accuracy, val_accuracy))\n",
    "    \n",
    "print('best validation accuracy achieved during cross-validation: %f' % best_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "id": "test"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "softmax on raw pixels final test set accuracy: 0.359000\n"
     ]
    }
   ],
   "source": [
    "# evaluate on test set\n",
    "# Evaluate the best softmax on test set\n",
    "y_test_pred = best_softmax.predict(X_test)\n",
    "test_accuracy = np.mean(y_test == y_test_pred)\n",
    "print('softmax on raw pixels final test set accuracy: %f' % (test_accuracy, ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Inline Question 2** - *True or False*\n",
    "\n",
    "Suppose the overall training loss is defined as the sum of the per-datapoint loss over all training examples. It is possible to add a new datapoint to a training set that would leave the SVM loss unchanged, but this is not the case with the Softmax classifier loss.\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$\n",
    "\n",
    "\n",
    "$\\color{blue}{\\textit Your Explanation:}$\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the learned weights for each class\n",
    "w = best_softmax.W[:-1,:] # strip out the bias\n",
    "w = w.reshape(32, 32, 3, 10)\n",
    "\n",
    "w_min, w_max = np.min(w), np.max(w)\n",
    "\n",
    "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n",
    "for i in range(10):\n",
    "    plt.subplot(2, 5, i + 1)\n",
    "    \n",
    "    # Rescale the weights to be between 0 and 255\n",
    "    wimg = 255.0 * (w[:, :, :, i].squeeze() - w_min) / (w_max - w_min)\n",
    "    plt.imshow(wimg.astype('uint8'))\n",
    "    plt.axis('off')\n",
    "    plt.title(classes[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
